#pragma once
#include <iostream>

namespace MyFunc
{
	template<class T>
	struct Node
	{
		T _data;
		Node<T>* _next;
		Node<T>* _prev;

		Node(const T& data)
			:_data(data)
			, _next(nullptr)
			, _prev(nullptr)
		{
		}

	};

	template<class T>
	struct Less
	{
		bool operator()(const T& t1, const T& t2)
		{
			return t1 < t2;
		}
	};

	template<class T>
	struct Great
	{
		bool operator()(const T& t1, const T& t2)
		{
			return t1 > t2;
		}
	};

	template<class T>
	struct EqualTo
	{
		bool operator()(const T& t1, const T& t2)
		{
			return t1 == t2;
		}
	};

	template<class T>
	struct NotEqualTo
	{
		bool operator()(const T& t1, const T& t2)
		{
			return t1 != t2;
		}
	};

	template<class T>
	struct LessNode
	{
		bool operator()(const Node<T>& node1, const Node<T>& node2)
		{
			return node1._data < node2._data;
		}
	};

	template<class T>
	struct GreatNode
	{
		bool operator()(const Node<T>& node1, const Node<T>& node2)
		{
			return node1._data > node2._data;
		}
	};

	template<class T>
	struct EqualToNode
	{
		bool operator()(const Node<T>& node1, const Node<T>& node2)
		{
			return node1._data == node2._data;
		}
	};

	template<class T>
	struct NotEqualToNode
	{
		bool operator()(const Node<T>& node1, const Node<T>& node2)
		{
			return node1._data != node2._data;
		}
	};

	template<class T>
	struct GetNodeData
	{
		T& operator()(Node<T>& node1)
		{
			return node1._data;
		}
	};

	template<class T>
	struct SetNodeData
	{
		Node<T> operator()(Node<T>& node1, const T& t)
		{
			node1._data = t;
			return node1;
		}
	};

}